package com.biosimilarity.naturalselection.model.dataset;
import com.biosimilarity.naturalselection.model.dataset.Absyn.*;
/*** BNFC-Generated Visitor Design Pattern Skeleton. ***/
/* This implements the common visitor design pattern.
   Tests show it to be slightly less efficient than the
   instanceof method, but easier to use. 
   Replace the R and A parameters with the desired return
   and context types.*/

public class VisitSkel
{
  public class RecordExprVisitor<R,A> implements RecordExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Joined p, A arg)
    {
      /* Code For Joined Goes Here */

      p.recordexpr_1.accept(new RecordExprVisitor<R,A>(), arg);
      p.recordexpr_2.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Isolated p, A arg)
    {
      /* Code For Isolated Goes Here */

      p.recordexpr_1.accept(new RecordExprVisitor<R,A>(), arg);
      p.recordexpr_2.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Consed p, A arg)
    {
      /* Code For Consed Goes Here */

      p.tupleexpr_.accept(new TupleExprVisitor<R,A>(), arg);
      p.recordexpr_.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Contexted p, A arg)
    {
      /* Code For Contexted Goes Here */

      for (Binding x : p.listbinding_) {
      }
      p.recordexpr_.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Referenced p, A arg)
    {
      /* Code For Referenced Goes Here */

      p.recordvariable_.accept(new RecordVariableVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Collected p, A arg)
    {
      /* Code For Collected Goes Here */

      p.collectionexpr_.accept(new CollectionExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Emptied p, A arg)
    {
      /* Code For Emptied Goes Here */


      return null;
    }

  }
  public class BindingVisitor<R,A> implements Binding.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.BindingExpr p, A arg)
    {
      /* Code For BindingExpr Goes Here */

      p.recordptn_1.accept(new RecordPtnVisitor<R,A>(), arg);
      p.recordptn_2.accept(new RecordPtnVisitor<R,A>(), arg);

      return null;
    }

  }
  public class RecordPtnVisitor<R,A> implements RecordPtn.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RecordDestructor p, A arg)
    {
      /* Code For RecordDestructor Goes Here */

      for (TuplePtn x : p.listtupleptn_) {
      }
      p.recordptn_.accept(new RecordPtnVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RecordLiteral p, A arg)
    {
      /* Code For RecordLiteral Goes Here */

      p.recordexpr_.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }

  }
  public class RecordVariableVisitor<R,A> implements RecordVariable.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RecordIdent p, A arg)
    {
      /* Code For RecordIdent Goes Here */

      //p.uident_;

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RecordWild p, A arg)
    {
      /* Code For RecordWild Goes Here */


      return null;
    }

  }
  public class CollectionExprVisitor<R,A> implements CollectionExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Extension p, A arg)
    {
      /* Code For Extension Goes Here */

      p.fieldformals_.accept(new FieldFormalsVisitor<R,A>(), arg);
      p.extensionbodyexpr_.accept(new ExtensionBodyExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Intension p, A arg)
    {
      /* Code For Intension Goes Here */

      p.fieldformals_.accept(new FieldFormalsVisitor<R,A>(), arg);
      p.intensionbodyexpr_.accept(new IntensionBodyExprVisitor<R,A>(), arg);

      return null;
    }

  }
  public class FieldFormalsVisitor<R,A> implements FieldFormals.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.FieldFormalSpec p, A arg)
    {
      /* Code For FieldFormalSpec Goes Here */

      for (FieldExpr x : p.listfieldexpr_) {
      }

      return null;
    }

  }
  public class ExtensionBodyExprVisitor<R,A> implements ExtensionBodyExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ExtensionBody p, A arg)
    {
      /* Code For ExtensionBody Goes Here */

      for (TupleExpr x : p.listtupleexpr_) {
      }

      return null;
    }

  }
  public class IntensionBodyExprVisitor<R,A> implements IntensionBodyExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.IntensionBody p, A arg)
    {
      /* Code For IntensionBody Goes Here */

      p.tupleptn_.accept(new TuplePtnVisitor<R,A>(), arg);
      for (TupleDeclOrCond x : p.listtupledeclorcond_) {
      }

      return null;
    }

  }
  public class FieldExprVisitor<R,A> implements FieldExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.FieldDecl p, A arg)
    {
      /* Code For FieldDecl Goes Here */

      p.fieldname_.accept(new FieldNameVisitor<R,A>(), arg);
      p.fieldtype_.accept(new FieldTypeVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.FieldActual p, A arg)
    {
      /* Code For FieldActual Goes Here */

      p.fieldname_.accept(new FieldNameVisitor<R,A>(), arg);

      return null;
    }

  }
  public class FieldNameVisitor<R,A> implements FieldName.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.FieldIdent p, A arg)
    {
      /* Code For FieldIdent Goes Here */

      //p.uident_;

      return null;
    }

  }
  public class TupleExprVisitor<R,A> implements TupleExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleSumExpr p, A arg)
    {
      /* Code For TupleSumExpr Goes Here */

      p.tupleexpr_1.accept(new TupleExprVisitor<R,A>(), arg);
      p.tupleexpr_2.accept(new TupleExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleBaseExpr p, A arg)
    {
      /* Code For TupleBaseExpr Goes Here */

      for (ValueExpr x : p.listvalueexpr_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleMultExpr p, A arg)
    {
      /* Code For TupleMultExpr Goes Here */

      p.tupleexpr_1.accept(new TupleExprVisitor<R,A>(), arg);
      p.tupleexpr_2.accept(new TupleExprVisitor<R,A>(), arg);

      return null;
    }

  }
  public class TupleDeclOrCondVisitor<R,A> implements TupleDeclOrCond.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ConditionIn p, A arg)
    {
      /* Code For ConditionIn Goes Here */

      p.tuplecond_.accept(new TupleCondVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.DeclIn p, A arg)
    {
      /* Code For DeclIn Goes Here */

      p.tuplegen_.accept(new TupleGenVisitor<R,A>(), arg);

      return null;
    }

  }
  public class TuplePtnVisitor<R,A> implements TuplePtn.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TuplePtnExpr p, A arg)
    {
      /* Code For TuplePtnExpr Goes Here */

      for (ValueExpr x : p.listvalueexpr_) {
      }

      return null;
    }

  }
  public class TupleGenVisitor<R,A> implements TupleGen.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleGenExpr p, A arg)
    {
      /* Code For TupleGenExpr Goes Here */

      p.tupleptn_.accept(new TuplePtnVisitor<R,A>(), arg);
      p.recordexpr_.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }

  }
  public class TupleCondVisitor<R,A> implements TupleCond.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleSatExpr p, A arg)
    {
      /* Code For TupleSatExpr Goes Here */

      p.tupleptn_.accept(new TuplePtnVisitor<R,A>(), arg);
      p.tuplecondition_.accept(new TupleConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleCompExpr p, A arg)
    {
      /* Code For TupleCompExpr Goes Here */

      p.valueexpr_1.accept(new ValueExprVisitor<R,A>(), arg);
      p.comparison_.accept(new ComparisonVisitor<R,A>(), arg);
      p.valueexpr_2.accept(new ValueExprVisitor<R,A>(), arg);

      return null;
    }

  }
  public class TupleConditionVisitor<R,A> implements TupleCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.DisjunctTupleCondition p, A arg)
    {
      /* Code For DisjunctTupleCondition Goes Here */

      p.tuplecondition_1.accept(new TupleConditionVisitor<R,A>(), arg);
      p.tuplecondition_2.accept(new TupleConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ConjunctTupleCondition p, A arg)
    {
      /* Code For ConjunctTupleCondition Goes Here */

      p.tuplecondition_1.accept(new TupleConditionVisitor<R,A>(), arg);
      p.tuplecondition_2.accept(new TupleConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.NegatedTupleCondition p, A arg)
    {
      /* Code For NegatedTupleCondition Goes Here */

      p.tuplecondition_.accept(new TupleConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.StructuralTupleCondition p, A arg)
    {
      /* Code For StructuralTupleCondition Goes Here */

      p.structuretuplecondition_.accept(new StructureTupleConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.BaseTupleCondition p, A arg)
    {
      /* Code For BaseTupleCondition Goes Here */

      p.groundtuplecondition_.accept(new GroundTupleConditionVisitor<R,A>(), arg);

      return null;
    }

  }
  public class StructureTupleConditionVisitor<R,A> implements StructureTupleCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleValCond p, A arg)
    {
      /* Code For TupleValCond Goes Here */

      for (ValueCondition x : p.listvaluecondition_) {
      }

      return null;
    }

  }
  public class GroundTupleConditionVisitor<R,A> implements GroundTupleCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleLogicGround p, A arg)
    {
      /* Code For TupleLogicGround Goes Here */

      p.logicalground_.accept(new LogicalGroundVisitor<R,A>(), arg);

      return null;
    }

  }
  public class ValueConditionVisitor<R,A> implements ValueCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.DisjunctValueCondition p, A arg)
    {
      /* Code For DisjunctValueCondition Goes Here */

      p.valuecondition_1.accept(new ValueConditionVisitor<R,A>(), arg);
      p.valuecondition_2.accept(new ValueConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ConjunctValueCondition p, A arg)
    {
      /* Code For ConjunctValueCondition Goes Here */

      p.valuecondition_1.accept(new ValueConditionVisitor<R,A>(), arg);
      p.valuecondition_2.accept(new ValueConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.NegatedValueCondition p, A arg)
    {
      /* Code For NegatedValueCondition Goes Here */

      p.valuecondition_.accept(new ValueConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.StructuralValueCondition p, A arg)
    {
      /* Code For StructuralValueCondition Goes Here */

      p.structurevaluecondition_.accept(new StructureValueConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.BaseValueCondition p, A arg)
    {
      /* Code For BaseValueCondition Goes Here */

      p.groundvaluecondition_.accept(new GroundValueConditionVisitor<R,A>(), arg);

      return null;
    }

  }
  public class GroundValueConditionVisitor<R,A> implements GroundValueCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueLogicGround p, A arg)
    {
      /* Code For ValueLogicGround Goes Here */

      p.logicalground_.accept(new LogicalGroundVisitor<R,A>(), arg);

      return null;
    }

  }
  public class StructureValueConditionVisitor<R,A> implements StructureValueCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueRecCond p, A arg)
    {
      /* Code For ValueRecCond Goes Here */

      p.recordcondition_.accept(new RecordConditionVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueListCond p, A arg)
    {
      /* Code For ValueListCond Goes Here */

      for (ValueCondition x : p.listvaluecondition_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueSetCond p, A arg)
    {
      /* Code For ValueSetCond Goes Here */

      for (ValueCondition x : p.listvaluecondition_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueLitCond p, A arg)
    {
      /* Code For ValueLitCond Goes Here */

      p.valueliteral_.accept(new ValueLiteralVisitor<R,A>(), arg);

      return null;
    }

  }
  public class RecordConditionVisitor<R,A> implements RecordCondition.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueRecBodyCond p, A arg)
    {
      /* Code For ValueRecBodyCond Goes Here */

      for (TupleCondition x : p.listtuplecondition_) {
      }
      p.recordcondition_.accept(new RecordConditionVisitor<R,A>(), arg);

      return null;
    }

  }
  public class LogicalGroundVisitor<R,A> implements LogicalGround.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Verity p, A arg)
    {
      /* Code For Verity Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Absurdity p, A arg)
    {
      /* Code For Absurdity Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Nullity p, A arg)
    {
      /* Code For Nullity Goes Here */


      return null;
    }

  }
  public class FieldTypeVisitor<R,A> implements FieldType.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.FieldTypeExpr p, A arg)
    {
      /* Code For FieldTypeExpr Goes Here */

      p.typeexpr_.accept(new TypeExprVisitor<R,A>(), arg);

      return null;
    }

  }
  public class TypeExprVisitor<R,A> implements TypeExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ArrayTypeExpr p, A arg)
    {
      /* Code For ArrayTypeExpr Goes Here */

      p.typeexpr_.accept(new TypeExprVisitor<R,A>(), arg);
      //p.integer_;

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RcrdTypeExpr p, A arg)
    {
      /* Code For RcrdTypeExpr Goes Here */

      p.typeformals_.accept(new TypeFormalsVisitor<R,A>(), arg);
      for (TypeExpr x : p.listtypeexpr_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RecTypeExpr p, A arg)
    {
      /* Code For RecTypeExpr Goes Here */

      p.typename_.accept(new TypeNameVisitor<R,A>(), arg);
      p.typeexpr_.accept(new TypeExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.RefTypeExpr p, A arg)
    {
      /* Code For RefTypeExpr Goes Here */

      p.typename_.accept(new TypeNameVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.CollTypeExpr p, A arg)
    {
      /* Code For CollTypeExpr Goes Here */

      p.colltype_.accept(new CollTypeVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.GroundTypeExpr p, A arg)
    {
      /* Code For GroundTypeExpr Goes Here */

      p.groundtype_.accept(new GroundTypeVisitor<R,A>(), arg);

      return null;
    }

  }
  public class CollTypeVisitor<R,A> implements CollType.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.LListTypeExpr p, A arg)
    {
      /* Code For LListTypeExpr Goes Here */

      for (TypeExpr x : p.listtypeexpr_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.SetTypeExpr p, A arg)
    {
      /* Code For SetTypeExpr Goes Here */

      for (TypeExpr x : p.listtypeexpr_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TupleTypeExpr p, A arg)
    {
      /* Code For TupleTypeExpr Goes Here */

      for (TypeExpr x : p.listtypeexpr_) {
      }

      return null;
    }

  }
  public class TypeNameVisitor<R,A> implements TypeName.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TypeIdent p, A arg)
    {
      /* Code For TypeIdent Goes Here */

      //p.uident_;

      return null;
    }

  }
  public class GroundTypeVisitor<R,A> implements GroundType.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.GroundInteger p, A arg)
    {
      /* Code For GroundInteger Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.GroundDouble p, A arg)
    {
      /* Code For GroundDouble Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.GroundString p, A arg)
    {
      /* Code For GroundString Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.GroundChar p, A arg)
    {
      /* Code For GroundChar Goes Here */


      return null;
    }

  }
  public class TypeFormalsVisitor<R,A> implements TypeFormals.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.TypeParameters p, A arg)
    {
      /* Code For TypeParameters Goes Here */

      for (TypeExpr x : p.listtypeexpr_) {
      }

      return null;
    }

  }
  public class ComparisonVisitor<R,A> implements Comparison.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Equality p, A arg)
    {
      /* Code For Equality Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.Less p, A arg)
    {
      /* Code For Less Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.More p, A arg)
    {
      /* Code For More Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.LEq p, A arg)
    {
      /* Code For LEq Goes Here */


      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.GEq p, A arg)
    {
      /* Code For GEq Goes Here */


      return null;
    }

  }
  public class ValueExprVisitor<R,A> implements ValueExpr.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueAddExpr p, A arg)
    {
      /* Code For ValueAddExpr Goes Here */

      p.valueexpr_1.accept(new ValueExprVisitor<R,A>(), arg);
      p.valueexpr_2.accept(new ValueExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueMultExpr p, A arg)
    {
      /* Code For ValueMultExpr Goes Here */

      p.valueexpr_1.accept(new ValueExprVisitor<R,A>(), arg);
      p.valueexpr_2.accept(new ValueExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueArrAccExpr p, A arg)
    {
      /* Code For ValueArrAccExpr Goes Here */

      p.valueexpr_1.accept(new ValueExprVisitor<R,A>(), arg);
      p.valueexpr_2.accept(new ValueExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueNegExpr p, A arg)
    {
      /* Code For ValueNegExpr Goes Here */

      p.valueexpr_.accept(new ValueExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueVarExpr p, A arg)
    {
      /* Code For ValueVarExpr Goes Here */

      p.valuevariable_.accept(new ValueVariableVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueLitExpr p, A arg)
    {
      /* Code For ValueLitExpr Goes Here */

      p.valueliteral_.accept(new ValueLiteralVisitor<R,A>(), arg);

      return null;
    }

  }
  public class ValueVariableVisitor<R,A> implements ValueVariable.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueIdent p, A arg)
    {
      /* Code For ValueIdent Goes Here */

      //p.lident_;

      return null;
    }

  }
  public class ValueLiteralVisitor<R,A> implements ValueLiteral.Visitor<R,A>
  {
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueRecLit p, A arg)
    {
      /* Code For ValueRecLit Goes Here */

      p.recordexpr_.accept(new RecordExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueRecProjLit p, A arg)
    {
      /* Code For ValueRecProjLit Goes Here */

      p.recordexpr_.accept(new RecordExprVisitor<R,A>(), arg);
      p.fieldexpr_.accept(new FieldExprVisitor<R,A>(), arg);

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueListLit p, A arg)
    {
      /* Code For ValueListLit Goes Here */

      for (ValueExpr x : p.listvalueexpr_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueSetLit p, A arg)
    {
      /* Code For ValueSetLit Goes Here */

      for (ValueExpr x : p.listvalueexpr_) {
      }

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueIntLit p, A arg)
    {
      /* Code For ValueIntLit Goes Here */

      //p.integer_;

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueDoubleLit p, A arg)
    {
      /* Code For ValueDoubleLit Goes Here */

      //p.double_;

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueStringLit p, A arg)
    {
      /* Code For ValueStringLit Goes Here */

      //p.string_;

      return null;
    }
    public R visit(com.biosimilarity.naturalselection.model.dataset.Absyn.ValueCharLit p, A arg)
    {
      /* Code For ValueCharLit Goes Here */

      //p.char_;

      return null;
    }

  }
}